package com.sg.service.biz.app.nb;

import cn.hutool.core.bean.BeanUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.dto.biz.app.common.SpecCycleDto;
import com.sg.dto.biz.app.common.TemplateCycleDto;
import com.sg.dto.biz.app.req.*;
import com.sg.dto.biz.app.res.*;
import com.sg.dto.integration.component.QuerySemanticEngineDetailReqDto;
import com.sg.dto.integration.component.QuerySemanticEngineDetailRespDto;
import com.wicket.okrcomponent.integration.TemplateEngineService;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

/**
 * @author ： 手工接入方法
 * @version 1.0
 * @since 2022/5/28 15:32
 */
@Service
public class NbCycleType {

    @Resource
    private TemplateEngineService fwCompTemplateEngineClient;

    /**
     * code:getPublicFieldCache
     * name:M3-获取接收字段（特殊方法）
     * desc:undefined
     * gen by moon at 8/28/2022, 4:06:20 PM
     **/
    @Trace(operationName = "M3-获取接收字段（特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ObtainReceiveFieldRespDto obtainReceiveField(ObtainReceiveFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ObtainReceiveFieldRespDto.class);
    }

    /**
     * code:getLastFromDataList
     * name:M3-取排序列表中上一条数据（特殊方法）
     * desc:undefined
     * gen by moon at 8/28/2022, 4:06:23 PM
     **/
    @Trace(operationName = "M3-取排序列表中上一条数据（特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ObtainGetLastFromDataListRespDto obtainGetLastFromDataList(ObtainGetLastFromDataListReqDto reqDto) {
        ObtainGetLastFromDataListRespDto retData = new ObtainGetLastFromDataListRespDto();
        //todo 该壳子不通用，设计工具需要改造成通用类型---zhouk 2022-12-08
        if (reqDto.getEvaObjTargetCycleReportSortList() == null || reqDto.getEvaObjTargetCycleReportSortList().size() == 0) {
            CycleDto lastData = new CycleDto();
            for (CycleDto oneData : reqDto.getCycleList()) {
                if (oneData.getCycleId().equals(reqDto.getCycleId())) {
                    retData.setLastCycleId(lastData.getCycleId());
                    break;
                }
                lastData = oneData;
            }
        } else {
            EvaObjTargetCycleReportSortDto lastData = new EvaObjTargetCycleReportSortDto();
            for (EvaObjTargetCycleReportSortDto oneData : reqDto.getEvaObjTargetCycleReportSortList()) {
                if (oneData.getEvaObjTargetCycleId().equals(reqDto.getEvaObjTargetCycleId())) {
                    retData.setLastEvaObjTargetCycleId(lastData.getEvaObjTargetCycleId());
                    break;
                }
                lastData = oneData;
            }
        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M3-生成周期类型名称
     * desc:undefined
     * gen by moon at 8/29/2022, 1:03:30 AM
     **/
    @Trace(operationName = "M3-生成周期类型名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateSemanticContentRespDto generateSemanticContent(GenerateSemanticContentReqDto reqDto) {
        //{cycleStartTime} 至 {cycleEndTime}
        boolean bRetFlag = false;
        GenerateSemanticContentRespDto retData = new GenerateSemanticContentRespDto();
        String retConent = "";
        QuerySemanticEngineDetailReqDto querySemanticEngineDetailReqDto = new QuerySemanticEngineDetailReqDto();
        querySemanticEngineDetailReqDto.setTemplateSemanticEngineCode("CREATE_IRREGULAR_CYCLE_NAME");
        QuerySemanticEngineDetailRespDto querySemanticEngineDetailRespDto = fwCompTemplateEngineClient.querySemanticEngineDetail(querySemanticEngineDetailReqDto).getData();
        if (querySemanticEngineDetailRespDto != null && querySemanticEngineDetailRespDto.getTemplateEngineTemplate() != null) {
            String cycleStartTime = "\\{cycleStartTime}";
            String cycleEndTime = "\\{cycleEndTime}";
            if (reqDto.getCycleStartTime() != null && reqDto.getCycleEndTime() != null) {
                bRetFlag = true;
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleStartTime, CommonFunctionHelper.date2Str(reqDto.getCycleStartTime()));
                retConent = retConent.replaceAll(cycleEndTime, CommonFunctionHelper.date2Str(reqDto.getCycleEndTime()));
            } else {
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleStartTime, "---");
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleEndTime, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }

        //{cycleStartName} - {cycleEndName}
        QuerySemanticEngineDetailReqDto querySemanticEngineDetailReqDto_2 = new QuerySemanticEngineDetailReqDto();
        querySemanticEngineDetailReqDto_2.setTemplateSemanticEngineCode("CREATE_IRREGULAR_CYCLE_NAME");
        QuerySemanticEngineDetailRespDto querySemanticEngineDetailRespDto_2 = fwCompTemplateEngineClient.querySemanticEngineDetail(querySemanticEngineDetailReqDto_2).getData();
        if (querySemanticEngineDetailRespDto_2 != null && querySemanticEngineDetailRespDto_2.getTemplateEngineTemplate() != null) {
            String cycleStartName = "\\{cycleStartName}";
            String cycleEndName = "\\{cycleEndName}";
            if (reqDto.getCycleStartName() != null && reqDto.getCycleEndName() != null) {
                bRetFlag = true;
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleStartName, reqDto.getCycleStartName());
                retConent = retConent.replaceAll(cycleEndName, reqDto.getCycleEndName());
            } else {
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleStartName, "---");
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleEndName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }

        //{acount}个{cycleTypeName}
        QuerySemanticEngineDetailReqDto querySemanticEngineDetailReqDto_3 = new QuerySemanticEngineDetailReqDto();
        querySemanticEngineDetailReqDto_3.setTemplateSemanticEngineCode("CREATE_IRREGULAR_CYCLE_TYPE_NAME");
        QuerySemanticEngineDetailRespDto querySemanticEngineDetailRespDto_3 = fwCompTemplateEngineClient.querySemanticEngineDetail(querySemanticEngineDetailReqDto_3).getData();
        if (querySemanticEngineDetailRespDto_3 != null && querySemanticEngineDetailRespDto_3.getTemplateEngineTemplate() != null) {
            String acount = "\\{acount}";
            String cycleTypeName = "\\{cycleTypeName}";
            if (reqDto.getAcount() != null && reqDto.getCycleTypeName() != null) {
                bRetFlag = true;
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(acount, String.valueOf(reqDto.getAcount()));
                retConent = retConent.replaceAll(cycleTypeName, reqDto.getCycleTypeName());
            } else {
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(acount, "---");
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleTypeName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }

        //{acount}{cycleTypeCode}
        QuerySemanticEngineDetailReqDto querySemanticEngineDetailReqDto_4 = new QuerySemanticEngineDetailReqDto();
        querySemanticEngineDetailReqDto_4.setTemplateSemanticEngineCode("CREATE_CYCLE_TYPE_CODE");
        QuerySemanticEngineDetailRespDto querySemanticEngineDetailRespDto_4 = fwCompTemplateEngineClient.querySemanticEngineDetail(querySemanticEngineDetailReqDto_4).getData();
        if (querySemanticEngineDetailRespDto_4 != null && querySemanticEngineDetailRespDto_4.getTemplateEngineTemplate() != null) {
            String acount = "\\{acount}";
            String cycleTypeCode = "\\{cycleTypeCode}";
            if (reqDto.getAcount() != null && reqDto.getCycleTypeCode() != null) {
                bRetFlag = true;
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(acount, String.valueOf(reqDto.getAcount()));
                retConent = retConent.replaceAll(cycleTypeCode, reqDto.getCycleTypeCode());
            } else {
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(acount, "---");
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleTypeCode, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }

        return retData;
    }

    /**
     * code:getSpecRecInSortedDataList
     * name:M3获取已排序数据集中的指定周期（特殊方法）
     * desc:undefined
     * gen by moon at 10/10/2022, 11:39:30 PM
     **/
    @Trace(operationName = "M3获取已排序数据集中的指定周期（特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ObtainGainSortDataSetAssignCycleRespDto obtainGainSortDataSetAssignCycle(ObtainGainSortDataSetAssignCycleReqDto reqDto) {
        ObtainGainSortDataSetAssignCycleRespDto retData = null;
        CycleDto target = null;
        Long count = 0L;
        for (CycleDto one : reqDto.getCycleList()) {
            count++;
            target = one;
            if (count == reqDto.getOutputNum()) {
                break;
            }
        }
        retData = BeanUtil.toBean(target, ObtainGainSortDataSetAssignCycleRespDto.class);
        return retData;
    }

    /**
     * code:receptionService
     * name:M3获取接收外部字段(特殊方法）
     * desc:undefined
     * gen by moon at 10/12/2022, 10:29:02 AM
     **/
    @Trace(operationName = "M3获取接收外部字段(特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ObtainReceiveOutFieldRespDto obtainReceiveOutField(ObtainReceiveOutFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ObtainReceiveOutFieldRespDto.class);
    }

    /**
     * code:generateSemanticInstance
     * name:M3-生成周期名称
     * desc:undefined
     * gen by moon at 10/14/2022, 1:33:33 AM
     **/
    @Trace(operationName = "M3-生成周期名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateTotalCycleNameRespDto generateTotalCycleName(GenerateTotalCycleNameReqDto reqDto) {
        //{cycleStartName} - {cycleEndName}
        boolean bRetFlag = false;
        GenerateTotalCycleNameRespDto retData = new GenerateTotalCycleNameRespDto();
        String retConent = "";
        QuerySemanticEngineDetailReqDto querySemanticEngineDetailReqDto = new QuerySemanticEngineDetailReqDto();
        querySemanticEngineDetailReqDto.setTemplateSemanticEngineCode("GENERATE_TOTAL_CYCLE_NAME");
        QuerySemanticEngineDetailRespDto querySemanticEngineDetailRespDto = fwCompTemplateEngineClient.querySemanticEngineDetail(querySemanticEngineDetailReqDto).getData();
        if (querySemanticEngineDetailRespDto != null && querySemanticEngineDetailRespDto.getTemplateEngineTemplate() != null) {
            String cycleStartName = "\\{cycleStartName}";
            String cycleEndName = "\\{cycleEndName}";
            if (reqDto.getCycleStartName() != null && !reqDto.getCycleStartName().isEmpty()
                    && reqDto.getCycleEndName() != null && !reqDto.getCycleEndName().isEmpty()) {
                bRetFlag = true;
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleStartName, reqDto.getCycleStartName());
                retConent = retConent.replaceAll(cycleEndName, reqDto.getCycleEndName());
            } else {
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleStartName, "---");
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleEndName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M3-生成不规则周期名称
     * desc:undefined
     * gen by moon at 10/14/2022, 1:33:40 AM
     **/
    @Trace(operationName = "M3-生成不规则周期名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateIrregularCycleNameRespDto generateIrregularCycleName(GenerateIrregularCycleNameReqDto reqDto) {
        //{cycleStartTime} 至 {cycleEndTime}
        boolean bRetFlag = false;
        GenerateIrregularCycleNameRespDto retData = new GenerateIrregularCycleNameRespDto();
        String retConent = "";
        QuerySemanticEngineDetailReqDto querySemanticEngineDetailReqDto = new QuerySemanticEngineDetailReqDto();
        querySemanticEngineDetailReqDto.setTemplateSemanticEngineCode("GENERATE_IRREGULAR_CYCLE_NAME");
        QuerySemanticEngineDetailRespDto querySemanticEngineDetailRespDto = fwCompTemplateEngineClient.querySemanticEngineDetail(querySemanticEngineDetailReqDto).getData();
        if (querySemanticEngineDetailRespDto != null && querySemanticEngineDetailRespDto.getTemplateEngineTemplate() != null) {
            String cycleStartTime = "\\{cycleStartTime}";
            String cycleEndTime = "\\{cycleEndTime}";
            if (reqDto.getCycleStartTime() != null
                    && reqDto.getCycleEndTime() != null) {
                bRetFlag = true;
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleStartTime, CommonFunctionHelper.date2Str(reqDto.getCycleStartTime()));
                retConent = retConent.replaceAll(cycleEndTime, CommonFunctionHelper.date2Str(reqDto.getCycleEndTime()));
            } else {
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleStartTime, "---");
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleEndTime, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M3-生成不规则周期类型名称
     * desc:undefined
     * gen by moon at 10/14/2022, 1:35:24 AM
     **/
    @Trace(operationName = "M3-生成不规则周期类型名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateIrregularCycleTypeNameRespDto createIrregularCycleTypeName(CreateIrregularCycleTypeNameReqDto reqDto) {
        //{acount}个{cycleTypeName}
        boolean bRetFlag = false;
        CreateIrregularCycleTypeNameRespDto retData = new CreateIrregularCycleTypeNameRespDto();
        String retConent = "";
        QuerySemanticEngineDetailReqDto querySemanticEngineDetailReqDto = new QuerySemanticEngineDetailReqDto();
        querySemanticEngineDetailReqDto.setTemplateSemanticEngineCode("CREATE_IRREGULAR_CYCLE_TYPE_NAME");
        QuerySemanticEngineDetailRespDto querySemanticEngineDetailRespDto = fwCompTemplateEngineClient.querySemanticEngineDetail(querySemanticEngineDetailReqDto).getData();
        if (querySemanticEngineDetailRespDto != null && querySemanticEngineDetailRespDto.getTemplateEngineTemplate() != null) {
            String acount = "\\{acount}";
            String cycleTypeName = "\\{cycleTypeName}";
            if (reqDto.getAcount() != null
                    && reqDto.getCycleTypeName() != null) {
                bRetFlag = true;
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(acount, String.valueOf(reqDto.getAcount()));
                retConent = retConent.replaceAll(cycleTypeName, reqDto.getCycleTypeName());
            } else {
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(acount, "---");
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleTypeName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M3-生成周期类型标识
     * desc:undefined
     * gen by moon at 10/14/2022, 1:53:40 AM
     **/
    @Trace(operationName = "M3-生成周期类型标识")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateCycleTypeCodeRespDto createCycleTypeCode(CreateCycleTypeCodeReqDto reqDto) {
        // {acount}{cycleTypeCode}
        boolean bRetFlag = false;
        CreateCycleTypeCodeRespDto retData = new CreateCycleTypeCodeRespDto();
        String retConent = "";
        QuerySemanticEngineDetailReqDto querySemanticEngineDetailReqDto = new QuerySemanticEngineDetailReqDto();
        querySemanticEngineDetailReqDto.setTemplateSemanticEngineCode("CREATE_CYCLE_TYPE_CODE");
        QuerySemanticEngineDetailRespDto querySemanticEngineDetailRespDto = fwCompTemplateEngineClient.querySemanticEngineDetail(querySemanticEngineDetailReqDto).getData();
        if (querySemanticEngineDetailRespDto != null && querySemanticEngineDetailRespDto.getTemplateEngineTemplate() != null) {
            String acount = "\\{acount}";
            String cycleTypeCode = "\\{cycleTypeCode}";
            if (reqDto.getAcount() != null
                    && reqDto.getCycleTypeCode() != null) {
                bRetFlag = true;
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(acount, String.valueOf(reqDto.getAcount()));
                retConent = retConent.replaceAll(cycleTypeCode, reqDto.getCycleTypeCode());
            } else {
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(acount, "---");
                retConent = querySemanticEngineDetailRespDto.getTemplateEngineTemplate().replaceAll(cycleTypeCode, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setCurrentContentCode(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:getCollectionsDiff
     * name:M3-获取数据集差集（查询启用周期类型-特殊周期类型=平台周期类型）
     * desc:undefined
     * gen by moon at 10/20/2022, 11:57:32 AM
     **/
    @Trace(operationName = "M3-获取数据集差集（查询启用周期类型-特殊周期类型=平台周期类型）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ObtainCollectionsDiffComRespDto obtainCollectionsDiffCom(ObtainCollectionsDiffComReqDto reqDto) {
        ObtainCollectionsDiffComRespDto retData = new ObtainCollectionsDiffComRespDto();
        List<String> filteredList = new ArrayList<>();
        for (String one : reqDto.getCollectionsDiffComFatList()) {
            if (!reqDto.getCollectionsDiffComSubList().contains(one)) {
                filteredList.add(one);
            }
        }
        retData.getCollectionsDiffList().addAll(filteredList);
        return retData;
    }

    /**
     * code:collectionsIntersectionsData
     * name:M3-获取数据集交集（查询启用周期类型与特殊周期类型都存在的周期类型）
     * desc:undefined
     * gen by moon at 10/20/2022, 11:57:39 AM
     **/
    @Trace(operationName = "M3-获取数据集交集（查询启用周期类型与特殊周期类型都存在的周期类型）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ObtainCollectionsIntersectionsDataRespDto obtainCollectionsIntersectionsData(ObtainCollectionsIntersectionsDataReqDto reqDto) {
        ObtainCollectionsIntersectionsDataRespDto retData = new ObtainCollectionsIntersectionsDataRespDto();
        for (String one : reqDto.getCollectionsIntersectionsDataAList()) {
            if (reqDto.getCollectionsIntersectionsDataBList().contains(one)) {
                retData.getCollectionsIntersectionsDataList().add(one);
            }
        }
        return retData;
    }

    /**
     * code:collectionsMergeData
     * name:M3-执行周期列表融合（合并平台周期列表+空间周期列表）
     * desc:undefined
     * gen by moon at 10/20/2022, 11:57:41 AM
     **/
    @Trace(operationName = "M3-执行周期列表融合（合并平台周期列表+空间周期列表）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementMergeCycleListRespDto implementMergeCycleList(ImplementMergeCycleListReqDto reqDto) {
        ImplementMergeCycleListRespDto retData = new ImplementMergeCycleListRespDto();
        for (TemplateCycleDto one : reqDto.getTemplateCycleList()) {
            MergeCycleDto elm = new MergeCycleDto();
            BeanUtil.copyProperties(one, elm);
            retData.getMergeCycleList().add(elm);
        }

        for (SpecCycleDto one : reqDto.getSpecCycleList()) {
            MergeCycleDto elm = new MergeCycleDto();
            BeanUtil.copyProperties(one, elm);
            retData.getMergeCycleList().add(elm);
        }
        return retData;
    }

    /**
     * code:receptionService
     * name:M3传输租户周期管理导航约定值
     * desc:undefined
     * gen by moon at 11/26/2022, 12:11:44 AM
     **/
    @Trace(operationName = "M3传输租户周期管理导航约定值")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementBizConstructAccessParameterFieldRespDto implementBizConstructAccessParameterField(ImplementBizConstructAccessParameterFieldReqDto reqDto) {


        return BeanUtil.toBean(reqDto, ImplementBizConstructAccessParameterFieldRespDto.class);
    }

    /**
     * code:columnToRow
     * name:M3-执行列转行（字段转数据集）
     * desc:undefined
     * gen by moon at 11/26/2022, 12:11:50 AM
     **/
    @Trace(operationName = "M3-执行列转行（字段转数据集）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementColumnToRowRespDto implementColumnToRow(ImplementColumnToRowReqDto reqDto) {
        ImplementColumnToRowRespDto retData = new ImplementColumnToRowRespDto();
        retData.getCollectionsAggregationList().add(reqDto.getCustomField1());
        retData.getCollectionsAggregationList().add(reqDto.getCustomField2());
        return retData;
    }

    /**
     * code:receptionService
     * name:M3执行获取出入参业务字段（特殊方法）
     * desc:undefined
     * gen by moon at 2/8/2023, 2:10:38 PM
     **/
    @Trace(operationName = "M3执行获取出入参业务字段（特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementAccessParameterBizFieldRespDto implementAccessParameterBizField(ImplementAccessParameterBizFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ImplementAccessParameterBizFieldRespDto.class);
    }

    /**
     * code:receptionService
     * name:M3约定：是
     * desc:undefined
     * gen by moon at 5/15/2023, 10:23:45 PM
     **/
    @Trace(operationName = "M3约定：是")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementAcceptFieldRespDto implementAcceptField(ImplementAcceptFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ImplementAcceptFieldRespDto.class);
    }

    /**
     * code:receptionService
     * name:M3约定是与否
     * desc:undefined
     * gen by moon at 3/29/2024, 8:52:12 PM
     **/
    @Trace(operationName = "M3约定是与否")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementEightReceivingFieldRespDto implementEightReceivingField(ImplementEightReceivingFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ImplementEightReceivingFieldRespDto.class);
    }
    //手工接入方法
}
